A Sort Of A Blog
旧游无处不堪寻,无寻处,惟有少年心
C Sharp(四)

这一篇,我们讲讲 C# 中关于继承的相关知识。

继承


通过继承我们可以定义新的派生类(derived class),来对基类(base class)进行扩展。
派生类的成员包括:

  • 本身声明的成员
  • 基类的成员

注意: 派生类不能删除它所继承的任何成员。

要声明一个派生类,需要在类名后跟一个冒号,然后跟基类名。与 Objective-C 的继承声明相同。

class DerivedClass : BaseClass
{
//...
}

继承的成员可以被访问,就像他们是派生类本身声明的一样:

class SomeClass
{
public string Field1 = "base class field";
public void Method1(string value)
{
Console.WriteLine("Base class -- Method1: {0}", value);
}
}

class OtherClass : SomeClass
{
public string Field2 = "derived class";
public void Method2(string value)
{
Console.WriteLine("Derived class -- Method2: {0}", value);
}
}

class Program
{
static void Main()
{
OtherClass oc = new OtherClass();

oc.Method1(oc.Field1);
oc.Method1(oc.Field2);
oc.Method2(oc.Field1);
oc.Method2(oc.Field2);
}
}

除了 object,所有的类都是派生类,object 是唯一的非派生类,他是继承层次结构的基础。
没有基类声明的类隐式直接派生自 object 类。
C# 中的继承是单继承,与 Objective-C、JavaScript 一样。
通常我们称一个类为派生类时,我们是说他直接派生自某个类而不是 object。

屏蔽基类成员

我们虽然不能删除基类的任何成员,但是我们可以使用与基类名相同名称的成员来屏蔽基类成员。
在派生类屏蔽基类成员的要点如下:

  • 要屏蔽一个数据成员,需要声明一个新的相同类型的同名成员
  • 要屏蔽一个函数成员,需要在派生类中声明带有相同签名的函数成员
  • 要然编译器知道我们故意屏蔽基类成员,需要使用 new 修饰符。否则屏蔽成员会报警告
class SomeClass
{
public string Field1 = "SomeClass Field1";
public void Method1(string value)
{
Console.WriteLine("SomeClass.Method1: {0}", value);
}
}

class OtherClass : SomeClass
{
new public string Field1 = "OtherClass Field1";
new public void Method1(string value)
{
Console.WriteLine("OtherClass.Method1: {0}", value);
}
}

class Program
{
static void Main()
{
OtherClass oc = new OtherClass();
oc.Method1(oc.Field1); //OtherClass.Method1: OtherClass Field1
}
}

基类访问

如果要在派生类中需要访问被屏蔽的成员,可以使用基类访问表达式来访问隐藏的成员。
基类访问表达式由关键字 base 后跟点操作符加要访问的成员:

Console.WriteLine("{0}", base.Field1);

如果程序需要经常使用这个特性,可能需要重新设计了。

使用基类的引用

派生类的引用指向整个类结构,包括基类部分。
如果有一个派生类引用,我们就可以获取对象基类部分的引用(使用类型转换):

class BaseClass
{
public void Print()
{
Console.WriteLine("This is base class method");
}
}

class DerivedClass : BaseClass
{
new public void Print()
{
Console.WriteLine("This is derived class method");
}
}

class Program
{
public static Main()
{
DerivedClass dc = new DerivedClass();
BaseClass bc = (BaseClass)dc;
dc.Print(); // derived class print
bc.Print(); // base class print
}
}

通过类型转换而来的”基类”,不能”看”到派生类的部分。

虚方法和覆写方法

虚方法可以使基类的引用访问”提升”至派生类,只需满足如下条件:

  • 派生类的方法和基类的方法的签名和返回值都一致
  • 基类方法使用 virtual 标注
  • 派生类方法使用 override 标注
class BaseClass
{
virtual public void Print()
{
Console.WriteLine("This is base class method");
}
}

class DerivedClass : BaseClass
{
override public void Print()
{
Console.WriteLine("This is derived class method");
}
}

class Program
{
public static Main()
{
DerivedClass dc = new DerivedClass();
BaseClass bc = (BaseClass)dc;
dc.Print(); // derived class print
bc.Print(); // derived class print
}
}

关于 virtual 和 override 修饰符的重要信息如下:

  • 覆写和被覆写的方法必须具有相同的访问性
  • 不能覆写 static 方法和非虚方法
  • 方法、属性、索引器和事件可以被声明为 virtual 和 override

覆写方法可以在继承的任何层次出现,方法的调用会沿着派生层次一直追溯到标记为 override 的最高派生类。

注意: Objective-C 没有虚方法的概念,Objective-C 中所有的方法都是虚方法:

@interface Animal: NSObject
- (void)sing;

@implementation Animal
- (void)sing {
NSLog(@"animal sing");
}

@interface Dog: Animal

@implementation Dog
- (void)sing {
NSLog(@"dog sing");
}

- (void)main {
Dog *dog = [[Dog alloc] init];
Animal *animal = dog;
[dog sing]; //"dog sing"
[animal sing]; //"dog sing"
}

虚方法是面向对象中多态的基础,多态性又叫动态绑定、推迟绑定或运行期绑定。是允许你将父对象设置成为一个或更多的它的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。

构造函数的执行

派生类对象有一部分就是基类对象:

  • 要创建对象的基类部分,需要隐式的调用基类的某个构造函数作为实例创建的一部分
  • 每个类在执行自己的构造函数之前要执行基类的构造函数

默认情况,构造对象时,将调用基类的无参构造函数,如果希望派生类调用的是有参构造的话,就需要构造函数初始化语句。
有两种形式的构造函数初始化语句:

  • 使用 base 并指明使用哪一个基类的构造函数
  • 使用 this 并指明使用哪一个当前类的构造函数
public MyDerivedClass
{
public MyDerivedClass(int x, string s)
: base(x, s)
{
//...
}
}

另外,我们可以需要在构造函数中使用当前类的其他构造:

class MyClass
{
readonly int a;
readonly int b;
public string FirstName;
public string LastName;
public MyClass()
{
a = 10;
b = 20;
}
public MyClass(string firstName)
: this()
{
FirstName = firstName;
//...
}
public MyClass(string lastName)
: this()
{
LastName = lastName;
//...
}
}

类的访问修饰符

类的可访问修饰符有两种: public 和 internal:

  • 标记为 public 的类可以被系统内任何程序集访问
  • 标记为 internal 的类只能被该类所在的程序集访问

注意: internal 是类的默认访问级别。

成员的访问修饰符

成员的默认的访问级别是 private,并且成员不能比他的类有更高的可访问性。

  • private 成员只能被他自己的类访问,不能被其他类访问,包括继承的类。但能被嵌套在他的类中的类访问
  • protected 成员访问级别与 private 一样,只是它允许派生自他的类访问该成员
  • internal 成员只对程序集内部可见
  • protected internal 成员对所有继承自他的类可以访问,也可以对他所在的程序集可访问(注意是并集而不是交集)

抽象成员和抽象类

抽象成员是指被设计为被覆写的函数成员,有以下特征:

  • 必须是函数成员
  • 必须是由 abstract 修饰符修饰
  • 没有方法实现代码块
abstract public void Print();

抽象成员只能在抽象类中声明,一共有 4 中类型的成员可以声明为抽象:

  • 方法
  • 属性
  • 事件
  • 索引

派生类重写抽象成员要是有 override 标记:

override public void Print()
{
Console.WriteLine("override abstract method");
}

抽象类就是被设计为被继承的类,抽象类只能作为其他类的基类:

  • 我们不能创建抽象类的实例
  • 抽象类也使用 abstract 修饰符修饰
abstract class MyAbstractClass
{

}

注意:

  • 抽象类中可以有非抽象成员
  • 抽象类可以派生自其他抽象类
  • 任何派生自抽象类的类必须实现所有抽象成员,除非她本身也是派生类
abstract class ClassA
{
//...
}

abstract class ClassB : ClassA
{
//...
}

密封类

密封类与抽象类相反,他不能被继承,使用 sealed 修饰。

sealed class MySealedClass
{
//...
}

静态类

  • 静态类中所有成员都是静态的
  • 静态类被标记为 static
  • 静态类是隐式密封的,也就是说,他不能被继承
  • 它可以有一个静态构造函数,但不能有实例构造函数

扩展方法

如果我们不能修改某个类的源文件,而希望给该类添加方法,可以使用扩展方法:

//必须是静态类
static class ExtendMyClass
{
//必须声明为 public 和 static 方法,参数传入要扩展的类的实例,并且前面加 this 关键字
public static double Avg(this MyBaseClass bc)
{
}
}

C# 命名约定

  • 帕斯卡命名: 命名空间、类名、方法、属性和公共字段
  • 驼峰命名: 私有变量和形参
  • 下划线加驼峰: 私有和受保护字段